<?php

namespace App\Models;

use Illuminate\Database\Eloquent\Factories\HasFactory;
use Illuminate\Foundation\Auth\User as Authenticatable;
use Illuminate\Notifications\Notifiable;
use Laravel\Sanctum\HasApiTokens;
use Illuminate\Database\Eloquent\Relations\BelongsToMany;
use Illuminate\Database\Eloquent\Relations\HasOne;
use Illuminate\Database\Eloquent\Relations\HasMany;
use Illuminate\Database\Eloquent\Relations\BelongsTo;
use Illuminate\Database\Eloquent\Casts\Attribute;

class User extends Authenticatable
{
    use HasApiTokens, HasFactory, Notifiable;

    /**
     * 表名
     */
    protected $table = 'users';

    /**
     * 可填充的字段
     */
    protected $fillable = [
        'username',
        'phone',
        'password',
        'avatar',
        'status',
        'last_login_at',
        'last_login_ip',
        'last_login_device',
        'password_changed_at',
        'preferences',
    ];

    /**
     * 隐藏的字段
     */
    protected $hidden = [
        'password',
        'remember_token',
    ];

    /**
     * 类型转换
     */
    protected $casts = [
        'last_login_at' => 'datetime',
        'password_changed_at' => 'datetime',
        'preferences' => 'array',
        'email_verified_at' => 'datetime',
    ];

    /**
     * 获取用户关联的员工信息
     */
    public function employee(): HasOne
    {
        return $this->hasOne(Employee::class, 'user_id');
    }

    /**
     * 获取用户角色
     */
    public function roles(): BelongsToMany
    {
        return $this->belongsToMany(Role::class, 'user_roles', 'user_id', 'role_id');
    }

    /**
     * 获取用户通知
     */
    public function notifications(): HasMany
    {
        return $this->hasMany(Notification::class, 'user_id');
    }

    /**
     * 获取用户操作日志
     */
    public function operationLogs(): HasMany
    {
        return $this->hasMany(OperationLog::class, 'user_id');
    }

    /**
     * 获取用户访问日志
     */
    public function accessLogs(): HasMany
    {
        return $this->hasMany(AccessLog::class, 'user_id');
    }

    /**
     * 检查用户是否有指定权限（兼容旧系统）
     */
    public function hasPermission(string $permission): bool
    {
        // 检查用户的角色中是否包含指定权限
        foreach ($this->roles as $role) {
            if ($role->hasPermission($permission)) {
                return true;
            }
        }
        return false;
    }

    /**
     * 检查用户是否有指定功能权限
     */
    public function hasFunctionPermission(string $functionCode): bool
    {
        // 超级管理员拥有所有权限
        if ($this->hasRole('super_admin')) {
            return true;
        }

        // 获取功能ID
        $function = FunctionModel::where('code', $functionCode)->where('status', 'active')->first();
        if (!$function) {
            return false;
        }

        // 检查用户的角色是否有该功能权限
        return $this->roles()
            ->where('roles.status', 'active')
            ->join('role_function_permissions', 'roles.id', '=', 'role_function_permissions.role_id')
            ->where('role_function_permissions.function_id', $function->id)
            ->exists();
    }

    /**
     * 检查用户是否有菜单访问权限
     */
    public function hasMenuPermission(string $menuCode): bool
    {
        // 超级管理员拥有所有权限
        if ($this->hasRole('super_admin')) {
            return true;
        }

        // 获取菜单ID
        $menu = Menu::where('code', $menuCode)->where('status', 'active')->first();
        if (!$menu) {
            return false;
        }

        // 获取用户的所有功能ID
        $functionIds = $this->roles()
            ->where('roles.status', 'active')
            ->join('role_function_permissions', 'roles.id', '=', 'role_function_permissions.role_id')
            ->pluck('role_function_permissions.function_id')
            ->unique()
            ->toArray();

        if (empty($functionIds)) {
            return false;
        }

        // 检查用户是否有该菜单的任一功能权限
        return $menu->functions()
            ->where('status', 'active')
            ->whereIn('id', $functionIds)
            ->exists();
    }

    /**
     * 获取用户的所有功能权限
     */
    public function getFunctionPermissions(): array
    {
        if ($this->hasRole('super_admin')) {
            // 超级管理员返回所有功能
            return FunctionModel::where('status', 'active')->pluck('code')->toArray();
        }

        // 获取用户的所有功能ID
        $functionIds = $this->roles()
            ->where('roles.status', 'active')
            ->join('role_function_permissions', 'roles.id', '=', 'role_function_permissions.role_id')
            ->pluck('role_function_permissions.function_id')
            ->unique()
            ->toArray();

        if (empty($functionIds)) {
            return [];
        }

        // 获取功能代码
        return FunctionModel::where('status', 'active')
            ->whereIn('id', $functionIds)
            ->pluck('code')
            ->toArray();
    }

    /**
     * 获取用户可访问的菜单
     */
    public function getAccessibleMenus()
    {
        // 超级管理员可以访问所有菜单
        if ($this->hasRole('super_admin')) {
            return Menu::active()->visible()->with('functions')->orderBy('sort_order')->get();
        }

        return Menu::getUserMenus($this);
    }

    /**
     * 检查用户是否可以使用指定功能（包含依赖检查）
     */
    public function canUseFunction(string $functionCode): bool
    {
        $function = FunctionModel::where('code', $functionCode)->where('status', 'active')->first();

        if (!$function) {
            return false;
        }

        // 检查是否有当前功能权限
        if (!$this->hasFunctionPermission($functionCode)) {
            return false;
        }

        // 检查依赖功能权限
        if (!empty($function->dependencies)) {
            foreach ($function->dependencies as $dependencyId) {
                $dependency = FunctionModel::find($dependencyId);
                if ($dependency && !$this->hasFunctionPermission($dependency->code)) {
                    return false;
                }
            }
        }

        return true;
    }

    /**
     * 检查用户是否有指定角色
     */
    public function hasRole(string $role): bool
    {
        return $this->roles()->where('code', $role)->exists();
    }

    /**
     * 获取用户头像完整URL
     */
    protected function avatar(): Attribute
    {
        return Attribute::make(
            get: function ($value) {
                if (!$value) {
                    return null;
                }

                // 如果是完整URL，直接返回
                if (filter_var($value, FILTER_VALIDATE_URL)) {
                    return $value;
                }

                // 如果是相对路径，拼接API路径
                return url('/api/files/avatar/' . $value);
            }
        );
    }

    /**
     * 获取用户状态标签
     */
    protected function statusLabel(): Attribute
    {
        return Attribute::make(
            get: function () {
                return match ($this->status) {
                    'active' => '正常',
                    'inactive' => '未激活',
                    'suspended' => '暂停',
                    'locked' => '锁定',
                    default => '未知',
                };
            }
        );
    }

    /**
     * 作用域：活跃用户
     */
    public function scopeActive($query)
    {
        return $query->where('status', 'active');
    }

    /**
     * 作用域：按状态筛选
     */
    public function scopeByStatus($query, string $status)
    {
        return $query->where('status', $status);
    }

    /**
     * 作用域：最近登录的用户
     */
    public function scopeRecentlyLoggedIn($query, int $days = 30)
    {
        return $query->where('last_login_at', '>=', now()->subDays($days));
    }
}